<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <title>session.js</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <link rel="stylesheet" href="../../../../css/reset.css" type="text/css" media="screen" />
<link rel="stylesheet" href="../../../../css/main.css" type="text/css" media="screen" />
<link rel="stylesheet" href="../../../../css/github.css" type="text/css" media="screen" />
<script src="../../../../js/jquery-1.3.2.min.js" type="text/javascript" charset="utf-8"></script>
<script src="../../../../js/jquery-effect.js" type="text/javascript" charset="utf-8"></script>
<script src="../../../../js/main.js" type="text/javascript" charset="utf-8"></script>
<script src="../../../../js/highlight.pack.js" type="text/javascript" charset="utf-8"></script>

</head>

<body>
    <div class="banner">
        
        <h1>
            session.js
        </h1>
        <ul class="files">
            
            <li>
                lib/assets/javascripts/session.js
                
            </li>
            <li>Last modified: 2017-01-04 10:35:26 +0800</li>
        </ul>
    </div>

    <div id="bodyContent">
        <div id="content">
  
    <div class="description">
      
<pre><code>jQuery Password Strength plugin for Twitter Bootstrap

Copyright (c) 2008-2013 Tane Piper
Copyright (c) 2013 Alejandro Blanco
Dual licensed under the MIT and GPL licenses.</code></pre>

<p>jQuery(document).ready(function() {</p>

<pre><code>&quot;use strict&quot;;
var options = {};
options.ui = {
  container: &quot;#pwd-container&quot;,
  showVerdictsInsideProgressBar: true,
  viewports: {
    progress: &quot;.pwstrength_viewport_progress&quot;
  }
};
options.common = {
  debug: true,
  onLoad: function() {
    $(&#39;#messages&#39;).text(&#39;Start typing password&#39;);
  }
};
$(&#39;:password&#39;).pwstrength(options);</code></pre>

<p>});</p>

<p>(function (jQuery) { // Source: src/rules.js</p>

<p>var rulesEngine = {};</p>

<p>try {</p>

<pre><code>if (!jQuery &amp;&amp; module &amp;&amp; module.exports) {
    var jQuery = require(&quot;jquery&quot;),
        jsdom = require(&quot;jsdom&quot;).jsdom;
    jQuery = jQuery(jsdom().parentWindow);
}</code></pre>

<p>} catch (ignore) {}</p>

<p>(function ($, rulesEngine) {</p>

<pre><code>&quot;use strict&quot;;
var validation = {};

rulesEngine.forbiddenSequences = [
    &quot;0123456789&quot;, &quot;abcdefghijklmnopqrstuvwxyz&quot;, &quot;qwertyuiop&quot;, &quot;asdfghjkl&quot;,
    &quot;zxcvbnm&quot;, &quot;!@#$%^&amp;*()_+&quot;
];

validation.wordNotEmail = function (options, word, score) {
    if (word.match(/^([\w\!\#$\%\&amp;\&#39;\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&amp;\&#39;\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i)) {
        return score;
    }
    return 0;
};

validation.wordLength = function (options, word, score) {
    var wordlen = word.length,
        lenScore = Math.pow(wordlen, options.rules.raisePower);
    if (wordlen &lt; options.common.minChar) {
        lenScore = (lenScore + score);
    }
    return lenScore;
};

validation.wordSimilarToUsername = function (options, word, score) {
    var username = $(options.common.usernameField).val();
    if (username &amp;&amp; word.toLowerCase().match(username.toLowerCase())) {
        return score;
    }
    return 0;
};

validation.wordTwoCharacterClasses = function (options, word, score) {
    if (word.match(/([a-z].*[A-Z])|([A-Z].*[a-z])/) ||
            (word.match(/([a-zA-Z])/) &amp;&amp; word.match(/([0-9])/)) ||
            (word.match(/(.[!,@,#,$,%,\^,&amp;,*,?,_,~])/) &amp;&amp; word.match(/[a-zA-Z0-9_]/))) {
        return score;
    }
    return 0;
};

validation.wordRepetitions = function (options, word, score) {
    if (word.match(/(.)\1\1/)) { return score; }
    return 0;
};

validation.wordSequences = function (options, word, score) {
    var found = false,
        j;
    if (word.length &gt; 2) {
        $.each(rulesEngine.forbiddenSequences, function (idx, seq) {
            var sequences = [seq, seq.split(&#39;&#39;).reverse().join(&#39;&#39;)];
            $.each(sequences, function (idx, sequence) {
                for (j = 0; j &lt; (word.length - 2); j += 1) { // iterate the word trough a sliding window of size 3:
                    if (sequence.indexOf(word.toLowerCase().substring(j, j + 3)) &gt; -1) {
                        found = true;
                    }
                }
            });
        });
        if (found) { return score; }
    }
    return 0;
};

validation.wordLowercase = function (options, word, score) {
    return word.match(/[a-z]/) &amp;&amp; score;
};

validation.wordUppercase = function (options, word, score) {
    return word.match(/[A-Z]/) &amp;&amp; score;
};

validation.wordOneNumber = function (options, word, score) {
    return word.match(/\d+/) &amp;&amp; score;
};

validation.wordThreeNumbers = function (options, word, score) {
    return word.match(/(.*[0-9].*[0-9].*[0-9])/) &amp;&amp; score;
};

validation.wordOneSpecialChar = function (options, word, score) {
    return word.match(/.[!,@,#,$,%,\^,&amp;,*,?,_,~]/) &amp;&amp; score;
};

validation.wordTwoSpecialChar = function (options, word, score) {
    return word.match(/(.*[!,@,#,$,%,\^,&amp;,*,?,_,~].*[!,@,#,$,%,\^,&amp;,*,?,_,~])/) &amp;&amp; score;
};

validation.wordUpperLowerCombo = function (options, word, score) {
    return word.match(/([a-z].*[A-Z])|([A-Z].*[a-z])/) &amp;&amp; score;
};

validation.wordLetterNumberCombo = function (options, word, score) {
    return word.match(/([a-zA-Z])/) &amp;&amp; word.match(/([0-9])/) &amp;&amp; score;
};

validation.wordLetterNumberCharCombo = function (options, word, score) {
    return word.match(/([a-zA-Z0-9].*[!,@,#,$,%,\^,&amp;,*,?,_,~])|([!,@,#,$,%,\^,&amp;,*,?,_,~].*[a-zA-Z0-9])/) &amp;&amp; score;
};

rulesEngine.validation = validation;

rulesEngine.executeRules = function (options, word) {
    var totalScore = 0;

    $.each(options.rules.activated, function (rule, active) {
        if (active) {
            var score = options.rules.scores[rule],
                funct = rulesEngine.validation[rule],
                result,
                errorMessage;

            if (!$.isFunction(funct)) {
                funct = options.rules.extra[rule];
            }

            if ($.isFunction(funct)) {
                result = funct(options, word, score);
                if (result) {
                    totalScore += result;
                }
                if (result &lt; 0 || (!$.isNumeric(result) &amp;&amp; !result)) {
                    errorMessage = options.ui.spanError(options, rule);
                    if (errorMessage.length &gt; 0) {
                        options.instances.errors.push(errorMessage);
                    }
                }
            }
        }
    });

    return totalScore;
};</code></pre>

<p>}(jQuery, rulesEngine));</p>

<p>try {</p>

<pre><code>if (module &amp;&amp; module.exports) {
    module.exports = rulesEngine;
}</code></pre>

<p>} catch (ignore) {}</p>

<p>// Source: src/options.js</p>

<p>var defaultOptions = {};</p>

<p>defaultOptions.common = {}; defaultOptions.common.minChar = 6;
defaultOptions.common.usernameField = “#username”;
defaultOptions.common.userInputs = [</p>

<pre><code>// Selectors for input fields with user input</code></pre>

<p>]; defaultOptions.common.onLoad = undefined; defaultOptions.common.onKeyUp
= undefined; defaultOptions.common.zxcvbn = false;
defaultOptions.common.debug = false;</p>

<p>defaultOptions.rules = {}; defaultOptions.rules.extra = {};
defaultOptions.rules.scores = {</p>

<pre><code>wordNotEmail: -100,
wordLength: -50,
wordSimilarToUsername: -100,
wordSequences: -50,
wordTwoCharacterClasses: 2,
wordRepetitions: -25,
wordLowercase: 1,
wordUppercase: 3,
wordOneNumber: 3,
wordThreeNumbers: 5,
wordOneSpecialChar: 3,
wordTwoSpecialChar: 5,
wordUpperLowerCombo: 2,
wordLetterNumberCombo: 2,
wordLetterNumberCharCombo: 2</code></pre>

<p>}; defaultOptions.rules.activated = {</p>

<pre><code>wordNotEmail: true,
wordLength: true,
wordSimilarToUsername: true,
wordSequences: true,
wordTwoCharacterClasses: false,
wordRepetitions: false,
wordLowercase: true,
wordUppercase: true,
wordOneNumber: true,
wordThreeNumbers: true,
wordOneSpecialChar: true,
wordTwoSpecialChar: true,
wordUpperLowerCombo: true,
wordLetterNumberCombo: true,
wordLetterNumberCharCombo: true</code></pre>

<p>}; defaultOptions.rules.raisePower = 1.4;</p>

<p>defaultOptions.ui = {}; defaultOptions.ui.bootstrap2 = false;
defaultOptions.ui.showProgressBar = true; defaultOptions.ui.showPopover =
false; defaultOptions.ui.showStatus = false; defaultOptions.ui.spanError =
function (options, key) {</p>

<pre><code>&quot;use strict&quot;;
var text = options.ui.errorMessages[key];
if (!text) { return &#39;&#39;; }
return &#39;&lt;span style=&quot;color: #d52929&quot;&gt;&#39; + text + &#39;&lt;/span&gt;&#39;;</code></pre>

<p>}; defaultOptions.ui.popoverError = function (errors) {</p>

<pre><code>&quot;use strict&quot;;
var message = &quot;&lt;div&gt;Errors:&lt;ul class=&#39;error-list&#39; style=&#39;margin-bottom: 0;&#39;&gt;&quot;;

jQuery.each(errors, function (idx, err) {
    message += &quot;&lt;li&gt;&quot; + err + &quot;&lt;/li&gt;&quot;;
});
message += &quot;&lt;/ul&gt;&lt;/div&gt;&quot;;
return message;</code></pre>

<p>}; defaultOptions.ui.errorMessages = {</p>

<pre><code>wordLength: &quot;Your password is too short&quot;,
wordNotEmail: &quot;Do not use your email as your password&quot;,
wordSimilarToUsername: &quot;Your password cannot contain your username&quot;,
wordTwoCharacterClasses: &quot;Use different character classes&quot;,
wordRepetitions: &quot;Too many repetitions&quot;,
wordSequences: &quot;Your password contains sequences&quot;</code></pre>

<p>}; defaultOptions.ui.verdicts = [“Weak”, “Normal”, “Medium”, “Strong”,
“Very Strong”]; defaultOptions.ui.showVerdicts = true;
defaultOptions.ui.showVerdictsInsideProgressBar = false;
defaultOptions.ui.showErrors = true; defaultOptions.ui.container =
undefined; defaultOptions.ui.viewports = {</p>

<pre><code>progress: undefined,
verdict: undefined,
errors: undefined</code></pre>

<p>}; defaultOptions.ui.scores = [14, 26, 38, 50];</p>

<p>// Source: src/ui.js</p>

<p>var ui = {};</p>

<p>(function ($, ui) {</p>

<pre><code>&quot;use strict&quot;;

var barClasses = [&quot;danger&quot;, &quot;warning&quot;, &quot;success&quot;],
    statusClasses = [&quot;error&quot;, &quot;warning&quot;, &quot;success&quot;];

ui.getContainer = function (options, $el) {
    var $container;

    $container = $(options.ui.container);
    if (!($container &amp;&amp; $container.length === 1)) {
        $container = $el.parent();
    }
    return $container;
};

ui.findElement = function ($container, viewport, cssSelector) {
    if (viewport) {
        return $container.find(viewport).find(cssSelector);
    }
    return $container.find(cssSelector);
};

ui.getUIElements = function (options, $el) {
    var $container, result;

    if (options.instances.viewports) {
        return options.instances.viewports;
    }

    $container = ui.getContainer(options, $el);

    result = {};
    result.$progressbar = ui.findElement($container, options.ui.viewports.progress, &quot;div.progress&quot;);
    if (options.ui.showVerdictsInsideProgressBar) {
        result.$verdict = result.$progressbar.find(&quot;span.password-verdict&quot;);
    }

    if (!options.ui.showPopover) {
        if (!options.ui.showVerdictsInsideProgressBar) {
            result.$verdict = ui.findElement($container, options.ui.viewports.verdict, &quot;span.password-verdict&quot;);
        }
        result.$errors = ui.findElement($container, options.ui.viewports.errors, &quot;ul.error-list&quot;);
    }

    options.instances.viewports = result;
    return result;
};

ui.initProgressBar = function (options, $el) {
    var $container = ui.getContainer(options, $el),
        progressbar = &quot;&lt;div class=&#39;progress&#39;&gt;&lt;div class=&#39;&quot;;

    if (!options.ui.bootstrap2) {
        progressbar += &quot;progress-&quot;;
    }
    progressbar += &quot;bar&#39;&gt;&quot;;
    if (options.ui.showVerdictsInsideProgressBar) {
        progressbar += &quot;&lt;span class=&#39;password-verdict&#39;&gt;&lt;/span&gt;&quot;;
    }
    progressbar += &quot;&lt;/div&gt;&lt;/div&gt;&quot;;

    if (options.ui.viewports.progress) {
        $container.find(options.ui.viewports.progress).append(progressbar);
    } else {
        $(progressbar).insertAfter($el);
    }
};

ui.initHelper = function (options, $el, html, viewport) {
    var $container = ui.getContainer(options, $el);
    if (viewport) {
        $container.find(viewport).append(html);
    } else {
        $(html).insertAfter($el);
    }
};

ui.initVerdict = function (options, $el) {
    ui.initHelper(options, $el, &quot;&lt;span class=&#39;password-verdict&#39;&gt;&lt;/span&gt;&quot;,
                    options.ui.viewports.verdict);
};

ui.initErrorList = function (options, $el) {
    ui.initHelper(options, $el, &quot;&lt;ul class=&#39;error-list&#39;&gt;&lt;/ul&gt;&quot;,
                    options.ui.viewports.errors);
};

ui.initPopover = function (options, $el) {
    $el.popover(&quot;destroy&quot;);
    $el.popover({
        html: true,
        placement: &quot;bottom&quot;,
        trigger: &quot;manual&quot;,
        content: &quot; &quot;
    });
};

ui.initUI = function (options, $el) {
    if (options.ui.showPopover) {
        ui.initPopover(options, $el);
    } else {
        if (options.ui.showErrors) { ui.initErrorList(options, $el); }
        if (options.ui.showVerdicts &amp;&amp; !options.ui.showVerdictsInsideProgressBar) {
            ui.initVerdict(options, $el);
        }
    }
    if (options.ui.showProgressBar) {
        ui.initProgressBar(options, $el);
    }
};

ui.possibleProgressBarClasses = [&quot;danger&quot;, &quot;warning&quot;, &quot;success&quot;];

ui.updateProgressBar = function (options, $el, cssClass, percentage) {
    var $progressbar = ui.getUIElements(options, $el).$progressbar,
        $bar = $progressbar.find(&quot;.progress-bar&quot;),
        cssPrefix = &quot;progress-&quot;;

    if (options.ui.bootstrap2) {
        $bar = $progressbar.find(&quot;.bar&quot;);
        cssPrefix = &quot;&quot;;
    }

    $.each(ui.possibleProgressBarClasses, function (idx, value) {
        $bar.removeClass(cssPrefix + &quot;bar-&quot; + value);
    });
    $bar.addClass(cssPrefix + &quot;bar-&quot; + barClasses[cssClass]);
    $bar.css(&quot;width&quot;, percentage + &#39;%&#39;);
};

ui.updateVerdict = function (options, $el, text) {
    var $verdict = ui.getUIElements(options, $el).$verdict;
    $verdict.text(text);
};

ui.updateErrors = function (options, $el) {
    var $errors = ui.getUIElements(options, $el).$errors,
        html = &quot;&quot;;
    $.each(options.instances.errors, function (idx, err) {
        html += &quot;&lt;li&gt;&quot; + err + &quot;&lt;/li&gt;&quot;;
    });
    $errors.html(html);
};

ui.updatePopover = function (options, $el, verdictText) {
    var popover = $el.data(&quot;bs.popover&quot;),
        html = &quot;&quot;,
        hide = true;

    if (options.ui.showVerdicts &amp;&amp;
            !options.ui.showVerdictsInsideProgressBar &amp;&amp;
            verdictText.length &gt; 0) {
        html = &quot;&lt;h5&gt;&lt;span class=&#39;password-verdict&#39;&gt;&quot; + verdictText +
            &quot;&lt;/span&gt;&lt;/h5&gt;&quot;;
        hide = false;
    }
    if (options.ui.showErrors) {
        if (options.instances.errors.length &gt; 0) {
            hide = false;
        }
        html += options.ui.popoverError(options.instances.errors);
    }

    if (hide) {
        $el.popover(&quot;hide&quot;);
        return;
    }

    if (options.ui.bootstrap2) { popover = $el.data(&quot;popover&quot;); }

    if (popover.$arrow &amp;&amp; popover.$arrow.parents(&quot;body&quot;).length &gt; 0) {
        $el.find(&quot;+ .popover .popover-content&quot;).html(html);
    } else {
        // It&#39;s hidden
        popover.options.content = html;
        $el.popover(&quot;show&quot;);
    }
};

ui.updateFieldStatus = function (options, $el, cssClass) {
    var targetClass = options.ui.bootstrap2 ? &quot;.control-group&quot; : &quot;.form-group&quot;,
        $container = $el.parents(targetClass).first();

    $.each(statusClasses, function (idx, css) {
        if (!options.ui.bootstrap2) { css = &quot;has-&quot; + css; }
        $container.removeClass(css);
    });

    cssClass = statusClasses[cssClass];
    if (!options.ui.bootstrap2) { cssClass = &quot;has-&quot; + cssClass; }
    $container.addClass(cssClass);
};

ui.percentage = function (score, maximun) {
    var result = Math.floor(100 * score / maximun);
    result = result &lt; 0 ? 0 : result;
    result = result &gt; 100 ? 100 : result;
    return result;
};

ui.getVerdictAndCssClass = function (options, score) {
    var cssClass, verdictText, level;

    if (score &lt;= 0) {
        cssClass = 0;
        level = -1;
        verdictText = options.ui.verdicts[0];
    } else if (score &lt; options.ui.scores[0]) {
        cssClass = 0;
        level = 0;
        verdictText = options.ui.verdicts[0];
    } else if (score &lt; options.ui.scores[1]) {
        cssClass = 0;
        level = 1;
        verdictText = options.ui.verdicts[1];
    } else if (score &lt; options.ui.scores[2]) {
        cssClass = 1;
        level = 2;
        verdictText = options.ui.verdicts[2];
    } else if (score &lt; options.ui.scores[3]) {
        cssClass = 1;
        level = 3;
        verdictText = options.ui.verdicts[3];
    } else {
        cssClass = 2;
        level = 4;
        verdictText = options.ui.verdicts[4];
    }

    return [verdictText, cssClass, level];
};

ui.updateUI = function (options, $el, score) {
    var cssClass, barPercentage, verdictText;

    cssClass = ui.getVerdictAndCssClass(options, score);
    verdictText = cssClass[0];
    cssClass = cssClass[1];

    if (options.ui.showProgressBar) {
        barPercentage = ui.percentage(score, options.ui.scores[3]);
        ui.updateProgressBar(options, $el, cssClass, barPercentage);
        if (options.ui.showVerdictsInsideProgressBar) {
            ui.updateVerdict(options, $el, verdictText);
        }
    }

    if (options.ui.showStatus) {
        ui.updateFieldStatus(options, $el, cssClass);
    }

    if (options.ui.showPopover) {
        ui.updatePopover(options, $el, verdictText);
    } else {
        if (options.ui.showVerdicts &amp;&amp; !options.ui.showVerdictsInsideProgressBar) {
            ui.updateVerdict(options, $el, verdictText);
        }
        if (options.ui.showErrors) {
            ui.updateErrors(options, $el);
        }
    }
};</code></pre>

<p>}(jQuery, ui));</p>

<p>// Source: src/methods.js</p>

<p>var methods = {};</p>

<p>(function ($, methods) {</p>

<pre><code>&quot;use strict&quot;;
var onKeyUp, applyToAll;

onKeyUp = function (event) {
    var $el = $(event.target),
        options = $el.data(&quot;pwstrength-bootstrap&quot;),
        word = $el.val(),
        userInputs,
        verdictText,
        verdictLevel,
        score;

    if (options === undefined) { return; }

    options.instances.errors = [];
    if (options.common.zxcvbn) {
        userInputs = [];
        $.each(options.common.userInputs, function (idx, selector) {
            userInputs.push($(selector).val());
        });
        userInputs.push($(options.common.usernameField).val());
        score = zxcvbn(word, userInputs).entropy;
    } else {
        score = rulesEngine.executeRules(options, word);
    }
    ui.updateUI(options, $el, score);
    verdictText = ui.getVerdictAndCssClass(options, score);
    verdictLevel = verdictText[2];
    verdictText = verdictText[0];

    if (options.common.debug) { console.log(score + &#39; - &#39; + verdictText); }

    if ($.isFunction(options.common.onKeyUp)) {
        options.common.onKeyUp(event, {
            score: score,
            verdictText: verdictText,
            verdictLevel: verdictLevel
        });
    }
};

methods.init = function (settings) {
    this.each(function (idx, el) {
        // Make it deep extend (first param) so it extends too the
        // rules and other inside objects
        var clonedDefaults = $.extend(true, {}, defaultOptions),
            localOptions = $.extend(true, clonedDefaults, settings),
            $el = $(el);

        localOptions.instances = {};
        $el.data(&quot;pwstrength-bootstrap&quot;, localOptions);
        $el.on(&quot;keyup&quot;, onKeyUp);
        $el.on(&quot;change&quot;, onKeyUp);
        $el.on(&quot;onpaste&quot;, onKeyUp);

        ui.initUI(localOptions, $el);
        if ($.trim($el.val())) { // Not empty, calculate the strength
            $el.trigger(&quot;keyup&quot;);
        }

        if ($.isFunction(localOptions.common.onLoad)) {
            localOptions.common.onLoad();
        }
    });

    return this;
};

methods.destroy = function () {
    this.each(function (idx, el) {
        var $el = $(el),
            options = $el.data(&quot;pwstrength-bootstrap&quot;),
            elements = ui.getUIElements(options, $el);
        elements.$progressbar.remove();
        elements.$verdict.remove();
        elements.$errors.remove();
        $el.removeData(&quot;pwstrength-bootstrap&quot;);
    });
};

methods.forceUpdate = function () {
    this.each(function (idx, el) {
        var event = { target: el };
        onKeyUp(event);
    });
};

methods.addRule = function (name, method, score, active) {
    this.each(function (idx, el) {
        var options = $(el).data(&quot;pwstrength-bootstrap&quot;);

        options.rules.activated[name] = active;
        options.rules.scores[name] = score;
        options.rules.extra[name] = method;
    });
};

applyToAll = function (rule, prop, value) {
    this.each(function (idx, el) {
        $(el).data(&quot;pwstrength-bootstrap&quot;).rules[prop][rule] = value;
    });
};

methods.changeScore = function (rule, score) {
    applyToAll.call(this, rule, &quot;scores&quot;, score);
};

methods.ruleActive = function (rule, active) {
    applyToAll.call(this, rule, &quot;activated&quot;, active);
};

$.fn.pwstrength = function (method) {
    var result;

    if (methods[method]) {
        result = methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
    } else if (typeof method === &quot;object&quot; || !method) {
        result = methods.init.apply(this, arguments);
    } else {
        $.error(&quot;Method &quot; +  method + &quot; does not exist on jQuery.pwstrength-bootstrap&quot;);
    }

    return result;
};</code></pre>

<p>}(jQuery, methods)); }(jQuery));</p>

    </div>
  


  


  
  


  


  

  



  

    

    

    


    


    <!-- Methods -->
              </div>

    </div>
  </body>
</html>
